'Weak Dependency Graph [60.0]'
------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ f(X) -> if(X, c(), n__f(n__true()))
, if(true(), X, Y) -> X
, if(false(), X, Y) -> activate(Y)
, f(X) -> n__f(X)
, true() -> n__true()
, activate(n__f(X)) -> f(activate(X))
, activate(n__true()) -> true()
, activate(X) -> X}
Details:
We have computed the following set of weak (innermost) dependency pairs:
{ f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, if^#(true(), X, Y) -> c_1()
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_3()
, true^#() -> c_4()
, activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, activate^#(n__true()) -> c_6(true^#())
, activate^#(X) -> c_7()}
The usable rules are:
{ activate(n__f(X)) -> f(activate(X))
, activate(n__true()) -> true()
, activate(X) -> X
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, true() -> n__true()
, if(true(), X, Y) -> X
, if(false(), X, Y) -> activate(Y)}
The estimated dependency graph contains the following edges:
{f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))}
==> {if^#(false(), X, Y) -> c_2(activate^#(Y))}
{f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))}
==> {if^#(true(), X, Y) -> c_1()}
{if^#(false(), X, Y) -> c_2(activate^#(Y))}
==> {activate^#(n__true()) -> c_6(true^#())}
{if^#(false(), X, Y) -> c_2(activate^#(Y))}
==> {activate^#(n__f(X)) -> c_5(f^#(activate(X)))}
{if^#(false(), X, Y) -> c_2(activate^#(Y))}
==> {activate^#(X) -> c_7()}
{activate^#(n__f(X)) -> c_5(f^#(activate(X)))}
==> {f^#(X) -> c_3()}
{activate^#(n__f(X)) -> c_5(f^#(activate(X)))}
==> {f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))}
{activate^#(n__true()) -> c_6(true^#())}
==> {true^#() -> c_4()}
We consider the following path(s):
1) { f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, activate^#(n__true()) -> c_6(true^#())
, true^#() -> c_4()}
The usable rules for this path are the following:
{ activate(n__f(X)) -> f(activate(X))
, activate(n__true()) -> true()
, activate(X) -> X
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, true() -> n__true()
, if(true(), X, Y) -> X
, if(false(), X, Y) -> activate(Y)}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ activate(n__f(X)) -> f(activate(X))
, activate(n__true()) -> true()
, activate(X) -> X
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, true() -> n__true()
, if(true(), X, Y) -> X
, if(false(), X, Y) -> activate(Y)
, activate^#(n__true()) -> c_6(true^#())
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, true^#() -> c_4()}
Details:
We apply the weight gap principle, strictly orienting the rules
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{true() -> n__true()}
and weakly orienting the rules
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{true() -> n__true()}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [1]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))}
and weakly orienting the rules
{ true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [8]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{if^#(false(), X, Y) -> c_2(activate^#(Y))}
and weakly orienting the rules
{ f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{if^#(false(), X, Y) -> c_2(activate^#(Y))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [8]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [8]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{activate^#(n__true()) -> c_6(true^#())}
and weakly orienting the rules
{ if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{activate^#(n__true()) -> c_6(true^#())}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [15]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{true^#() -> c_4()}
and weakly orienting the rules
{ activate^#(n__true()) -> c_6(true^#())
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{true^#() -> c_4()}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [7]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [1]
c_4() = [0]
c_5(x1) = [1] x1 + [8]
c_6(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{if(false(), X, Y) -> activate(Y)}
and weakly orienting the rules
{ true^#() -> c_4()
, activate^#(n__true()) -> c_6(true^#())
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{if(false(), X, Y) -> activate(Y)}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [8]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [15]
c_6(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)}
and weakly orienting the rules
{ if(false(), X, Y) -> activate(Y)
, true^#() -> c_4()
, activate^#(n__true()) -> c_6(true^#())
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [1]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [8]
activate(x1) = [1] x1 + [8]
f^#(x1) = [1] x1 + [8]
c_0(x1) = [1] x1 + [8]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{activate^#(n__f(X)) -> c_5(f^#(activate(X)))}
and weakly orienting the rules
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, if(false(), X, Y) -> activate(Y)
, true^#() -> c_4()
, activate^#(n__true()) -> c_6(true^#())
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{activate^#(n__f(X)) -> c_5(f^#(activate(X)))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [8]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [8]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [8]
c_3() = [0]
true^#() = [8]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {activate(n__f(X)) -> f(activate(X))}
Weak Rules:
{ activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, if(false(), X, Y) -> activate(Y)
, true^#() -> c_4()
, activate^#(n__true()) -> c_6(true^#())
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {activate(n__f(X)) -> f(activate(X))}
Weak Rules:
{ activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, if(false(), X, Y) -> activate(Y)
, true^#() -> c_4()
, activate^#(n__true()) -> c_6(true^#())
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
Details:
The problem is Match-bounded by 2.
The enriched problem is compatible with the following automaton:
{ f_1(6) -> 4
, f_1(6) -> 6
, f_2(15) -> 4
, f_2(15) -> 6
, if_1(6, 8, 9) -> 4
, if_1(6, 8, 9) -> 6
, if_2(6, 17, 18) -> 4
, if_2(6, 17, 18) -> 6
, if_2(15, 17, 18) -> 4
, if_2(15, 17, 18) -> 6
, c_0() -> 2
, c_0() -> 4
, c_0() -> 6
, c_1() -> 4
, c_1() -> 6
, c_1() -> 8
, c_2() -> 4
, c_2() -> 6
, c_2() -> 17
, n__f_0(2) -> 2
, n__f_0(2) -> 4
, n__f_0(2) -> 6
, n__f_1(6) -> 4
, n__f_1(6) -> 6
, n__f_1(10) -> 4
, n__f_1(10) -> 6
, n__f_1(10) -> 9
, n__f_2(15) -> 4
, n__f_2(15) -> 6
, n__f_2(19) -> 4
, n__f_2(19) -> 6
, n__f_2(19) -> 18
, n__true_0() -> 2
, n__true_0() -> 4
, n__true_0() -> 6
, n__true_1() -> 6
, n__true_1() -> 10
, n__true_1() -> 15
, n__true_2() -> 15
, n__true_2() -> 19
, true_0() -> 4
, true_1() -> 6
, true_2() -> 15
, false_0() -> 2
, false_0() -> 4
, false_0() -> 6
, activate_0(2) -> 4
, activate_1(2) -> 6
, activate_1(9) -> 4
, activate_1(9) -> 6
, activate_1(18) -> 4
, activate_1(18) -> 6
, activate_2(10) -> 15
, activate_2(19) -> 15
, f^#_0(2) -> 1
, f^#_0(4) -> 3
, f^#_1(6) -> 7
, f^#_2(15) -> 16
, c_0_0(1) -> 1
, c_0_0(5) -> 3
, c_0_1(11) -> 1
, c_0_1(12) -> 3
, c_0_1(13) -> 7
, c_0_2(20) -> 7
, c_0_2(21) -> 16
, if^#_0(2, 2, 2) -> 1
, if^#_0(4, 2, 2) -> 5
, if^#_1(2, 8, 9) -> 11
, if^#_1(4, 8, 9) -> 12
, if^#_1(6, 8, 9) -> 13
, if^#_2(6, 17, 18) -> 20
, if^#_2(15, 17, 18) -> 21
, c_2_0(1) -> 1
, c_2_0(1) -> 5
, c_2_1(14) -> 11
, c_2_1(14) -> 12
, c_2_1(14) -> 13
, c_2_1(22) -> 20
, activate^#_0(2) -> 1
, activate^#_1(9) -> 14
, activate^#_1(18) -> 22
, true^#_0() -> 1
, c_4_0() -> 1
, c_5_0(3) -> 1
, c_5_1(7) -> 1
, c_5_2(16) -> 14
, c_5_2(16) -> 22
, c_6_0(1) -> 1}
2) { f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, activate^#(n__true()) -> c_6(true^#())}
The usable rules for this path are the following:
{ activate(n__f(X)) -> f(activate(X))
, activate(n__true()) -> true()
, activate(X) -> X
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, true() -> n__true()
, if(true(), X, Y) -> X
, if(false(), X, Y) -> activate(Y)}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ activate(n__f(X)) -> f(activate(X))
, activate(n__true()) -> true()
, activate(X) -> X
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, true() -> n__true()
, if(true(), X, Y) -> X
, if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, activate^#(n__true()) -> c_6(true^#())}
Details:
We apply the weight gap principle, strictly orienting the rules
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{activate^#(n__true()) -> c_6(true^#())}
and weakly orienting the rules
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{activate^#(n__true()) -> c_6(true^#())}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{true() -> n__true()}
and weakly orienting the rules
{ activate^#(n__true()) -> c_6(true^#())
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{true() -> n__true()}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [1]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))}
and weakly orienting the rules
{ true() -> n__true()
, activate^#(n__true()) -> c_6(true^#())
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [4]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [4]
c_6(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{if^#(false(), X, Y) -> c_2(activate^#(Y))}
and weakly orienting the rules
{ f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate^#(n__true()) -> c_6(true^#())
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{if^#(false(), X, Y) -> c_2(activate^#(Y))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [8]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [8]
c_1() = [0]
c_2(x1) = [1] x1 + [1]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{if(false(), X, Y) -> activate(Y)}
and weakly orienting the rules
{ if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate^#(n__true()) -> c_6(true^#())
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{if(false(), X, Y) -> activate(Y)}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [8]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [8]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [0]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [8]
c_6(x1) = [1] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{activate^#(n__f(X)) -> c_5(f^#(activate(X)))}
and weakly orienting the rules
{ if(false(), X, Y) -> activate(Y)
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate^#(n__true()) -> c_6(true^#())
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{activate^#(n__f(X)) -> c_5(f^#(activate(X)))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [8]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [8]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)}
and weakly orienting the rules
{ activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, if(false(), X, Y) -> activate(Y)
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate^#(n__true()) -> c_6(true^#())
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [8]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [8]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [1] x1 + [1]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {activate(n__f(X)) -> f(activate(X))}
Weak Rules:
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, if(false(), X, Y) -> activate(Y)
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate^#(n__true()) -> c_6(true^#())
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {activate(n__f(X)) -> f(activate(X))}
Weak Rules:
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, if(false(), X, Y) -> activate(Y)
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate^#(n__true()) -> c_6(true^#())
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
Details:
The problem is Match-bounded by 2.
The enriched problem is compatible with the following automaton:
{ f_1(6) -> 4
, f_1(6) -> 6
, f_2(15) -> 4
, f_2(15) -> 6
, if_1(6, 7, 8) -> 4
, if_1(6, 7, 8) -> 6
, if_2(6, 16, 17) -> 4
, if_2(6, 16, 17) -> 6
, if_2(15, 16, 17) -> 4
, if_2(15, 16, 17) -> 6
, c_0() -> 2
, c_0() -> 4
, c_0() -> 6
, c_1() -> 4
, c_1() -> 6
, c_1() -> 7
, c_2() -> 4
, c_2() -> 6
, c_2() -> 16
, n__f_0(2) -> 2
, n__f_0(2) -> 4
, n__f_0(2) -> 6
, n__f_1(6) -> 4
, n__f_1(6) -> 6
, n__f_1(9) -> 4
, n__f_1(9) -> 6
, n__f_1(9) -> 8
, n__f_2(15) -> 4
, n__f_2(15) -> 6
, n__f_2(18) -> 4
, n__f_2(18) -> 6
, n__f_2(18) -> 17
, n__true_0() -> 2
, n__true_0() -> 4
, n__true_0() -> 6
, n__true_1() -> 6
, n__true_1() -> 9
, n__true_1() -> 15
, n__true_2() -> 15
, n__true_2() -> 18
, true_0() -> 4
, true_1() -> 6
, true_2() -> 15
, false_0() -> 2
, false_0() -> 4
, false_0() -> 6
, activate_0(2) -> 4
, activate_1(2) -> 6
, activate_1(8) -> 4
, activate_1(8) -> 6
, activate_1(17) -> 4
, activate_1(17) -> 6
, activate_2(9) -> 15
, activate_2(18) -> 15
, f^#_0(2) -> 1
, f^#_0(4) -> 3
, f^#_1(6) -> 10
, f^#_2(15) -> 19
, c_0_0(1) -> 1
, c_0_0(5) -> 3
, c_0_1(11) -> 1
, c_0_1(12) -> 3
, c_0_1(13) -> 10
, c_0_2(20) -> 10
, c_0_2(21) -> 19
, if^#_0(2, 2, 2) -> 1
, if^#_0(4, 2, 2) -> 5
, if^#_1(2, 7, 8) -> 11
, if^#_1(4, 7, 8) -> 12
, if^#_1(6, 7, 8) -> 13
, if^#_2(6, 16, 17) -> 20
, if^#_2(15, 16, 17) -> 21
, c_2_0(1) -> 1
, c_2_0(1) -> 5
, c_2_1(14) -> 11
, c_2_1(14) -> 12
, c_2_1(14) -> 13
, c_2_1(22) -> 20
, activate^#_0(2) -> 1
, activate^#_1(8) -> 14
, activate^#_1(17) -> 22
, true^#_0() -> 1
, c_5_0(3) -> 1
, c_5_1(10) -> 1
, c_5_2(19) -> 14
, c_5_2(19) -> 22
, c_6_0(1) -> 1}
3) { f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, if^#(false(), X, Y) -> c_2(activate^#(Y))}
The usable rules for this path are the following:
{ activate(n__f(X)) -> f(activate(X))
, activate(n__true()) -> true()
, activate(X) -> X
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, true() -> n__true()
, if(true(), X, Y) -> X
, if(false(), X, Y) -> activate(Y)}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ activate(n__f(X)) -> f(activate(X))
, activate(n__true()) -> true()
, activate(X) -> X
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, true() -> n__true()
, if(true(), X, Y) -> X
, if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, if^#(false(), X, Y) -> c_2(activate^#(Y))}
Details:
We apply the weight gap principle, strictly orienting the rules
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{true() -> n__true()}
and weakly orienting the rules
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{true() -> n__true()}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [1]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [1]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [3]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))}
and weakly orienting the rules
{ true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [2]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{if^#(false(), X, Y) -> c_2(activate^#(Y))}
and weakly orienting the rules
{ f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{if^#(false(), X, Y) -> c_2(activate^#(Y))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [12]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [4]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{if(false(), X, Y) -> activate(Y)}
and weakly orienting the rules
{ if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{if(false(), X, Y) -> activate(Y)}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [8]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [15]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [0]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [1]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{activate(n__f(X)) -> f(activate(X))}
and weakly orienting the rules
{ if(false(), X, Y) -> activate(Y)
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{activate(n__f(X)) -> f(activate(X))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [3]
n__true() = [0]
true() = [1]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [8]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [0]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [8]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{activate^#(n__f(X)) -> c_5(f^#(activate(X)))}
and weakly orienting the rules
{ activate(n__f(X)) -> f(activate(X))
, if(false(), X, Y) -> activate(Y)
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{activate^#(n__f(X)) -> c_5(f^#(activate(X)))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [8]
activate(x1) = [1] x1 + [0]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)}
Weak Rules:
{ activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, activate(n__f(X)) -> f(activate(X))
, if(false(), X, Y) -> activate(Y)
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)}
Weak Rules:
{ activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, activate(n__f(X)) -> f(activate(X))
, if(false(), X, Y) -> activate(Y)
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
Details:
The problem is Match-bounded by 3.
The enriched problem is compatible with the following automaton:
{ f_0(4) -> 4
, f_1(10) -> 10
, f_1(17) -> 4
, f_2(22) -> 10
, if_1(4, 6, 7) -> 4
, if_2(10, 14, 15) -> 10
, if_2(17, 14, 15) -> 4
, if_3(22, 25, 26) -> 10
, c_0() -> 2
, c_0() -> 4
, c_0() -> 10
, c_1() -> 4
, c_1() -> 6
, c_2() -> 4
, c_2() -> 10
, c_2() -> 14
, c_3() -> 10
, c_3() -> 25
, n__f_0(2) -> 2
, n__f_0(2) -> 4
, n__f_0(2) -> 10
, n__f_1(4) -> 4
, n__f_1(8) -> 4
, n__f_1(8) -> 7
, n__f_2(10) -> 10
, n__f_2(16) -> 10
, n__f_2(16) -> 15
, n__f_2(17) -> 4
, n__f_3(22) -> 10
, n__f_3(27) -> 26
, n__true_0() -> 2
, n__true_0() -> 4
, n__true_0() -> 10
, n__true_1() -> 8
, n__true_1() -> 10
, n__true_1() -> 17
, n__true_1() -> 21
, n__true_2() -> 16
, n__true_2() -> 21
, n__true_2() -> 22
, n__true_3() -> 27
, true_0() -> 4
, true_1() -> 10
, true_1() -> 17
, true_2() -> 21
, true_2() -> 22
, false_0() -> 2
, false_0() -> 4
, false_0() -> 10
, activate_0(2) -> 4
, activate_1(2) -> 10
, activate_1(7) -> 4
, activate_1(8) -> 17
, activate_1(15) -> 10
, activate_2(8) -> 21
, activate_2(16) -> 22
, f^#_0(2) -> 1
, f^#_0(4) -> 3
, f^#_1(10) -> 9
, f^#_2(21) -> 20
, f^#_2(22) -> 28
, c_0_0(1) -> 1
, c_0_0(5) -> 3
, c_0_1(11) -> 1
, c_0_1(12) -> 3
, c_0_1(13) -> 9
, c_0_2(19) -> 9
, c_0_2(24) -> 20
, c_0_3(29) -> 20
, c_0_3(30) -> 28
, if^#_0(2, 2, 2) -> 1
, if^#_0(4, 2, 2) -> 5
, if^#_1(2, 6, 7) -> 11
, if^#_1(4, 6, 7) -> 12
, if^#_1(10, 6, 7) -> 13
, if^#_2(10, 14, 15) -> 19
, if^#_2(21, 14, 15) -> 24
, if^#_3(21, 25, 26) -> 29
, if^#_3(22, 25, 26) -> 30
, c_2_0(1) -> 1
, c_2_0(1) -> 5
, c_2_1(18) -> 11
, c_2_1(18) -> 12
, c_2_1(18) -> 13
, c_2_1(23) -> 19
, activate^#_0(2) -> 1
, activate^#_1(7) -> 18
, activate^#_1(15) -> 23
, c_5_0(3) -> 1
, c_5_1(9) -> 1
, c_5_2(20) -> 18
, c_5_2(28) -> 23}
4) { f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, activate^#(X) -> c_7()}
The usable rules for this path are the following:
{ activate(n__f(X)) -> f(activate(X))
, activate(n__true()) -> true()
, activate(X) -> X
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, true() -> n__true()
, if(true(), X, Y) -> X
, if(false(), X, Y) -> activate(Y)}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ activate(n__f(X)) -> f(activate(X))
, activate(n__true()) -> true()
, activate(X) -> X
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, true() -> n__true()
, if(true(), X, Y) -> X
, if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, activate^#(X) -> c_7()}
Details:
We apply the weight gap principle, strictly orienting the rules
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, activate^#(X) -> c_7()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, activate^#(X) -> c_7()}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{true() -> n__true()}
and weakly orienting the rules
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, activate^#(X) -> c_7()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{true() -> n__true()}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [1]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [3]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{if^#(false(), X, Y) -> c_2(activate^#(Y))}
and weakly orienting the rules
{ true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, activate^#(X) -> c_7()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{if^#(false(), X, Y) -> c_2(activate^#(Y))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [2]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))}
and weakly orienting the rules
{ if^#(false(), X, Y) -> c_2(activate^#(Y))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, activate^#(X) -> c_7()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [8]
c_0(x1) = [1] x1 + [2]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [0]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{if(false(), X, Y) -> activate(Y)}
and weakly orienting the rules
{ f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, activate^#(X) -> c_7()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{if(false(), X, Y) -> activate(Y)}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [8]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [9]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{activate(n__f(X)) -> f(activate(X))}
and weakly orienting the rules
{ if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, activate^#(X) -> c_7()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{activate(n__f(X)) -> f(activate(X))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [3]
n__true() = [0]
true() = [1]
false() = [9]
activate(x1) = [1] x1 + [8]
f^#(x1) = [1] x1 + [8]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [5]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{activate^#(n__f(X)) -> c_5(f^#(activate(X)))}
and weakly orienting the rules
{ activate(n__f(X)) -> f(activate(X))
, if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, activate^#(X) -> c_7()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{activate^#(n__f(X)) -> c_5(f^#(activate(X)))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [9]
activate(x1) = [1] x1 + [0]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)}
Weak Rules:
{ activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, activate(n__f(X)) -> f(activate(X))
, if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, activate^#(X) -> c_7()}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)}
Weak Rules:
{ activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, activate(n__f(X)) -> f(activate(X))
, if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, activate^#(X) -> c_7()}
Details:
The problem is Match-bounded by 3.
The enriched problem is compatible with the following automaton:
{ f_0(4) -> 4
, f_1(10) -> 10
, f_1(20) -> 4
, f_2(25) -> 10
, if_1(4, 6, 7) -> 4
, if_2(10, 15, 16) -> 10
, if_2(20, 15, 16) -> 4
, if_3(25, 27, 28) -> 10
, c_0() -> 2
, c_0() -> 4
, c_0() -> 10
, c_1() -> 4
, c_1() -> 6
, c_2() -> 4
, c_2() -> 10
, c_2() -> 15
, c_3() -> 10
, c_3() -> 27
, n__f_0(2) -> 2
, n__f_0(2) -> 4
, n__f_0(2) -> 10
, n__f_1(4) -> 4
, n__f_1(8) -> 4
, n__f_1(8) -> 7
, n__f_2(10) -> 10
, n__f_2(17) -> 10
, n__f_2(17) -> 16
, n__f_2(20) -> 4
, n__f_3(25) -> 10
, n__f_3(29) -> 28
, n__true_0() -> 2
, n__true_0() -> 4
, n__true_0() -> 10
, n__true_1() -> 8
, n__true_1() -> 10
, n__true_1() -> 19
, n__true_1() -> 20
, n__true_2() -> 17
, n__true_2() -> 19
, n__true_2() -> 25
, n__true_3() -> 29
, true_0() -> 4
, true_1() -> 10
, true_1() -> 20
, true_2() -> 19
, true_2() -> 25
, false_0() -> 2
, false_0() -> 4
, false_0() -> 10
, activate_0(2) -> 4
, activate_1(2) -> 10
, activate_1(7) -> 4
, activate_1(8) -> 20
, activate_1(16) -> 10
, activate_2(8) -> 19
, activate_2(17) -> 25
, f^#_0(2) -> 1
, f^#_0(4) -> 3
, f^#_1(10) -> 9
, f^#_2(19) -> 18
, f^#_2(25) -> 24
, c_0_0(1) -> 1
, c_0_0(5) -> 3
, c_0_1(11) -> 1
, c_0_1(12) -> 3
, c_0_1(13) -> 9
, c_0_2(21) -> 9
, c_0_2(22) -> 18
, c_0_2(26) -> 24
, c_0_3(30) -> 18
, c_0_3(31) -> 24
, if^#_0(2, 2, 2) -> 1
, if^#_0(4, 2, 2) -> 5
, if^#_1(2, 6, 7) -> 11
, if^#_1(4, 6, 7) -> 12
, if^#_1(10, 6, 7) -> 13
, if^#_2(10, 15, 16) -> 21
, if^#_2(19, 15, 16) -> 22
, if^#_2(25, 15, 16) -> 26
, if^#_3(19, 27, 28) -> 30
, if^#_3(25, 27, 28) -> 31
, c_2_0(1) -> 1
, c_2_0(1) -> 5
, c_2_1(14) -> 11
, c_2_1(14) -> 12
, c_2_1(14) -> 13
, c_2_1(23) -> 21
, activate^#_0(2) -> 1
, activate^#_1(7) -> 14
, activate^#_1(16) -> 23
, c_5_0(3) -> 1
, c_5_1(9) -> 1
, c_5_2(18) -> 14
, c_5_2(24) -> 23
, c_7_0() -> 1
, c_7_1() -> 14
, c_7_1() -> 23}
5) { f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, if^#(true(), X, Y) -> c_1()}
The usable rules for this path are the following:
{ activate(n__f(X)) -> f(activate(X))
, activate(n__true()) -> true()
, activate(X) -> X
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, true() -> n__true()
, if(true(), X, Y) -> X
, if(false(), X, Y) -> activate(Y)}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ activate(n__f(X)) -> f(activate(X))
, activate(n__true()) -> true()
, activate(X) -> X
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, true() -> n__true()
, if(true(), X, Y) -> X
, if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, if^#(true(), X, Y) -> c_1()}
Details:
We apply the weight gap principle, strictly orienting the rules
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, if^#(true(), X, Y) -> c_1()}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, if^#(true(), X, Y) -> c_1()}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [4]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{true() -> n__true()}
and weakly orienting the rules
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, if^#(true(), X, Y) -> c_1()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{true() -> n__true()}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [1]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [0]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))}
and weakly orienting the rules
{ true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, if^#(true(), X, Y) -> c_1()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [8]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [0]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{if(false(), X, Y) -> activate(Y)}
and weakly orienting the rules
{ f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, if^#(true(), X, Y) -> c_1()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{if(false(), X, Y) -> activate(Y)}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [8]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [8]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [1]
activate^#(x1) = [1] x1 + [0]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)}
and weakly orienting the rules
{ if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, if^#(true(), X, Y) -> c_1()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [9]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c() = [0]
n__f(x1) = [1] x1 + [6]
n__true() = [0]
true() = [1]
false() = [8]
activate(x1) = [1] x1 + [8]
f^#(x1) = [1] x1 + [7]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [8]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{activate^#(n__f(X)) -> c_5(f^#(activate(X)))}
and weakly orienting the rules
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, if^#(true(), X, Y) -> c_1()}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{activate^#(n__f(X)) -> c_5(f^#(activate(X)))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [8]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [8]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [3]
activate^#(x1) = [1] x1 + [2]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {activate(n__f(X)) -> f(activate(X))}
Weak Rules:
{ activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, if^#(true(), X, Y) -> c_1()}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules: {activate(n__f(X)) -> f(activate(X))}
Weak Rules:
{ activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, true() -> n__true()
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, if^#(true(), X, Y) -> c_1()}
Details:
The problem is Match-bounded by 2.
The enriched problem is compatible with the following automaton:
{ f_1(6) -> 4
, f_1(6) -> 6
, f_2(18) -> 4
, f_2(18) -> 6
, if_1(6, 8, 9) -> 4
, if_1(6, 8, 9) -> 6
, if_2(6, 20, 21) -> 4
, if_2(6, 20, 21) -> 6
, if_2(18, 20, 21) -> 4
, if_2(18, 20, 21) -> 6
, c_0() -> 2
, c_0() -> 4
, c_0() -> 6
, c_1() -> 4
, c_1() -> 6
, c_1() -> 8
, c_2() -> 4
, c_2() -> 6
, c_2() -> 20
, n__f_0(2) -> 2
, n__f_0(2) -> 4
, n__f_0(2) -> 6
, n__f_1(6) -> 4
, n__f_1(6) -> 6
, n__f_1(10) -> 4
, n__f_1(10) -> 6
, n__f_1(10) -> 9
, n__f_2(18) -> 4
, n__f_2(18) -> 6
, n__f_2(22) -> 4
, n__f_2(22) -> 6
, n__f_2(22) -> 21
, n__true_0() -> 2
, n__true_0() -> 4
, n__true_0() -> 6
, n__true_1() -> 6
, n__true_1() -> 10
, n__true_1() -> 16
, n__true_1() -> 18
, n__true_2() -> 18
, n__true_2() -> 22
, true_0() -> 4
, true_1() -> 6
, true_1() -> 16
, true_2() -> 18
, false_0() -> 2
, false_0() -> 4
, false_0() -> 6
, activate_0(2) -> 4
, activate_1(2) -> 6
, activate_1(9) -> 4
, activate_1(9) -> 6
, activate_1(10) -> 16
, activate_1(21) -> 4
, activate_1(21) -> 6
, activate_2(10) -> 18
, activate_2(22) -> 18
, f^#_0(2) -> 1
, f^#_0(4) -> 3
, f^#_1(6) -> 7
, f^#_1(16) -> 15
, f^#_2(18) -> 19
, c_0_0(1) -> 1
, c_0_0(5) -> 3
, c_0_1(11) -> 1
, c_0_1(12) -> 3
, c_0_1(13) -> 7
, c_0_1(17) -> 15
, c_0_2(23) -> 7
, c_0_2(24) -> 15
, c_0_2(25) -> 19
, if^#_0(2, 2, 2) -> 1
, if^#_0(4, 2, 2) -> 5
, if^#_1(2, 8, 9) -> 11
, if^#_1(4, 8, 9) -> 12
, if^#_1(6, 8, 9) -> 13
, if^#_1(16, 8, 9) -> 17
, if^#_2(6, 20, 21) -> 23
, if^#_2(16, 20, 21) -> 24
, if^#_2(18, 20, 21) -> 25
, c_1_0() -> 5
, c_1_1() -> 12
, c_1_1() -> 13
, c_1_1() -> 17
, c_1_2() -> 23
, c_1_2() -> 24
, c_1_2() -> 25
, c_2_0(1) -> 1
, c_2_0(1) -> 5
, c_2_1(14) -> 11
, c_2_1(14) -> 12
, c_2_1(14) -> 13
, c_2_1(26) -> 23
, activate^#_0(2) -> 1
, activate^#_1(9) -> 14
, activate^#_1(21) -> 26
, c_5_0(3) -> 1
, c_5_1(7) -> 1
, c_5_1(15) -> 14
, c_5_2(19) -> 14
, c_5_2(19) -> 26}
6) { f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_3()}
The usable rules for this path are the following:
{ activate(n__f(X)) -> f(activate(X))
, activate(n__true()) -> true()
, activate(X) -> X
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, true() -> n__true()
, if(true(), X, Y) -> X
, if(false(), X, Y) -> activate(Y)}
We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs.
'Weight Gap Principle'
----------------------
Answer: YES(?,O(n^1))
Input Problem: innermost runtime-complexity with respect to
Rules:
{ activate(n__f(X)) -> f(activate(X))
, activate(n__true()) -> true()
, activate(X) -> X
, f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)
, true() -> n__true()
, if(true(), X, Y) -> X
, if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, f^#(X) -> c_3()}
Details:
We apply the weight gap principle, strictly orienting the rules
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
and weakly orienting the rules
{}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ true() -> n__true()
, if^#(false(), X, Y) -> c_2(activate^#(Y))}
and weakly orienting the rules
{ activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ true() -> n__true()
, if^#(false(), X, Y) -> c_2(activate^#(Y))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [1]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [1]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [2]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{ f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, f^#(X) -> c_3()}
and weakly orienting the rules
{ true() -> n__true()
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{ f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, f^#(X) -> c_3()}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [0]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [8]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [0]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{if(false(), X, Y) -> activate(Y)}
and weakly orienting the rules
{ f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, f^#(X) -> c_3()
, true() -> n__true()
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{if(false(), X, Y) -> activate(Y)}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [8]
activate(x1) = [1] x1 + [1]
f^#(x1) = [1] x1 + [9]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [9]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{activate(n__f(X)) -> f(activate(X))}
and weakly orienting the rules
{ if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, f^#(X) -> c_3()
, true() -> n__true()
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{activate(n__f(X)) -> f(activate(X))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [1]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [3]
c() = [0]
n__f(x1) = [1] x1 + [3]
n__true() = [0]
true() = [1]
false() = [10]
activate(x1) = [1] x1 + [8]
f^#(x1) = [1] x1 + [8]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [4]
c_1() = [0]
c_2(x1) = [1] x1 + [0]
activate^#(x1) = [1] x1 + [5]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
We apply the weight gap principle, strictly orienting the rules
{activate^#(n__f(X)) -> c_5(f^#(activate(X)))}
and weakly orienting the rules
{ activate(n__f(X)) -> f(activate(X))
, if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, f^#(X) -> c_3()
, true() -> n__true()
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
using the following strongly linear interpretation:
Processor 'Matrix Interpretation' oriented the following rules strictly:
{activate^#(n__f(X)) -> c_5(f^#(activate(X)))}
Details:
Interpretation Functions:
f(x1) = [1] x1 + [0]
if(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
c() = [0]
n__f(x1) = [1] x1 + [0]
n__true() = [0]
true() = [0]
false() = [9]
activate(x1) = [1] x1 + [0]
f^#(x1) = [1] x1 + [0]
c_0(x1) = [1] x1 + [0]
if^#(x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
c_1() = [0]
c_2(x1) = [1] x1 + [2]
activate^#(x1) = [1] x1 + [1]
c_3() = [0]
true^#() = [0]
c_4() = [0]
c_5(x1) = [1] x1 + [0]
c_6(x1) = [0] x1 + [0]
c_7() = [0]
Finally we apply the subprocessor
'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment''
------------------------------------------------------------------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)}
Weak Rules:
{ activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, activate(n__f(X)) -> f(activate(X))
, if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, f^#(X) -> c_3()
, true() -> n__true()
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
Details:
The problem was solved by processor 'Bounds with default enrichment':
'Bounds with default enrichment'
--------------------------------
Answer: YES(?,O(n^1))
Input Problem: innermost relative runtime-complexity with respect to
Strict Rules:
{ f(X) -> if(X, c(), n__f(n__true()))
, f(X) -> n__f(X)}
Weak Rules:
{ activate^#(n__f(X)) -> c_5(f^#(activate(X)))
, activate(n__f(X)) -> f(activate(X))
, if(false(), X, Y) -> activate(Y)
, f^#(X) -> c_0(if^#(X, c(), n__f(n__true())))
, f^#(X) -> c_3()
, true() -> n__true()
, if^#(false(), X, Y) -> c_2(activate^#(Y))
, activate(n__true()) -> true()
, activate(X) -> X
, if(true(), X, Y) -> X}
Details:
The problem is Match-bounded by 3.
The enriched problem is compatible with the following automaton:
{ f_0(4) -> 4
, f_1(10) -> 10
, f_1(20) -> 4
, f_2(25) -> 10
, if_1(4, 6, 7) -> 4
, if_2(10, 15, 16) -> 10
, if_2(20, 15, 16) -> 4
, if_3(25, 27, 28) -> 10
, c_0() -> 2
, c_0() -> 4
, c_0() -> 10
, c_1() -> 4
, c_1() -> 6
, c_2() -> 4
, c_2() -> 10
, c_2() -> 15
, c_3() -> 10
, c_3() -> 27
, n__f_0(2) -> 2
, n__f_0(2) -> 4
, n__f_0(2) -> 10
, n__f_1(4) -> 4
, n__f_1(8) -> 4
, n__f_1(8) -> 7
, n__f_2(10) -> 10
, n__f_2(17) -> 10
, n__f_2(17) -> 16
, n__f_2(20) -> 4
, n__f_3(25) -> 10
, n__f_3(29) -> 28
, n__true_0() -> 2
, n__true_0() -> 4
, n__true_0() -> 10
, n__true_1() -> 8
, n__true_1() -> 10
, n__true_1() -> 19
, n__true_1() -> 20
, n__true_2() -> 17
, n__true_2() -> 19
, n__true_2() -> 25
, n__true_3() -> 29
, true_0() -> 4
, true_1() -> 10
, true_1() -> 20
, true_2() -> 19
, true_2() -> 25
, false_0() -> 2
, false_0() -> 4
, false_0() -> 10
, activate_0(2) -> 4
, activate_1(2) -> 10
, activate_1(7) -> 4
, activate_1(8) -> 20
, activate_1(16) -> 10
, activate_2(8) -> 19
, activate_2(17) -> 25
, f^#_0(2) -> 1
, f^#_0(4) -> 3
, f^#_1(10) -> 9
, f^#_2(19) -> 18
, f^#_2(25) -> 24
, c_0_0(1) -> 1
, c_0_0(5) -> 3
, c_0_1(11) -> 1
, c_0_1(12) -> 3
, c_0_1(13) -> 9
, c_0_2(21) -> 9
, c_0_2(22) -> 18
, c_0_2(26) -> 24
, c_0_3(30) -> 18
, c_0_3(31) -> 24
, if^#_0(2, 2, 2) -> 1
, if^#_0(4, 2, 2) -> 5
, if^#_1(2, 6, 7) -> 11
, if^#_1(4, 6, 7) -> 12
, if^#_1(10, 6, 7) -> 13
, if^#_2(10, 15, 16) -> 21
, if^#_2(19, 15, 16) -> 22
, if^#_2(25, 15, 16) -> 26
, if^#_3(19, 27, 28) -> 30
, if^#_3(25, 27, 28) -> 31
, c_2_0(1) -> 1
, c_2_0(1) -> 5
, c_2_1(14) -> 11
, c_2_1(14) -> 12
, c_2_1(14) -> 13
, c_2_1(23) -> 21
, activate^#_0(2) -> 1
, activate^#_1(7) -> 14
, activate^#_1(16) -> 23
, c_3_0() -> 1
, c_3_0() -> 3
, c_3_1() -> 9
, c_3_2() -> 18
, c_3_2() -> 24
, c_5_0(3) -> 1
, c_5_1(9) -> 1
, c_5_2(18) -> 14
, c_5_2(24) -> 23}